package com.elawlink.util;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * 操作日期工具类
 *
 */
public class DateUtil {

	private static final ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>();

	private static final Object object = new Object();

	public static final String PATTERN_GRACE = "yyyy/MM/dd HH:mm:ss";
	public static final String PATTERN_GRACE_NORMAL = "yyyy/MM/dd HH:mm";
	public static final String PATTERN_GRACE_SIMPLE = "yyyy/MM/dd";

	// Classical style
	public static final String PATTERN_CLASSICAL = "yyyy-MM-dd HH:mm:ss";
	public static final String PATTERN_CLASSICAL_NORMAL = "yyyy-MM-dd HH:mm";
	public static final String PATTERN_CLASSICAL_MONTH = "yyyy-MM";
	public static final String PATTERN_CLASSICAL_SIMPLE = "yyyy-MM-dd";
	public static final String PATTERN_DMY = "dd/MM/yyyy";
	
	public static final SimpleDateFormat sdf_yMdHms = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	public static String formatDate(SimpleDateFormat sdf,Date date){
		return sdf_yMdHms.format(date);
	}
		
	
	/**
  	 * 字符串转日期
  	 * @param str
  	 * @return
  	 */
    public static Date stringToDate(String str) {  
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        Date date = null;  
        try {  
            date = format.parse(str);   
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return date;  
    }  
    
    /**
  	 * 数字字符串转日期
  	 * @param str
  	 * @return
  	 */
    public static Date numStringToDate(String str) {  
        DateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");  
        Date date = null;  
        try {  
            date = format.parse(str);   
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return date;  
    }  
		
    /**
  	 * 数字字符串转日期
  	 * @param str
  	 * @return
  	 */
    public static Date strToDate(String str) {  
        DateFormat format = new SimpleDateFormat(PATTERN_CLASSICAL);  
        Date date = null;  
        try {  
            date = format.parse(str);   
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return date;  
    }  
    
	/**
	 * 根据默认格式将指定字符串解析成日期
	 * 
	 * @param str
	 *            指定字符串
	 * @return 返回解析后的日期
	 */
	public static Date parse(String str) {
		if (str.contains("/")) {
			return parse(str, PATTERN_GRACE_SIMPLE);
		}
		return parse(str, PATTERN_CLASSICAL_SIMPLE);

	}
	
	public static String formatDate(Date src, String formatPattern) {
		if (src == null) {
			return "";
		}
		DateFormat fmt = new SimpleDateFormat(formatPattern);
		return fmt.format(src);
	}
	
	/**
	 * >0代表后者大
	 * <0代表前者大
	 * @param smdate
	 * @param bdate
	 * @return
	 * @throws ParseException
	 */
	public static int daysBetween(Date smdate, Date bdate) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		smdate = sdf.parse(sdf.format(smdate));
		bdate = sdf.parse(sdf.format(bdate));
		Calendar cal = Calendar.getInstance();
		cal.setTime(smdate);
		long time1 = cal.getTimeInMillis();
		cal.setTime(bdate);
		long time2 = cal.getTimeInMillis();
		long between_days = (time2 - time1) / (1000 * 3600 * 24);

		return Integer.parseInt(String.valueOf(between_days));
	}
	
	/**
	 * >0代表后者大
	 * <0代表前者大
	 * @param smdate
	 * @param bdate
	 * @return
	 * @throws ParseException
	 */
	public static int timeBetween(Date smdate, Date bdate) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		smdate = sdf.parse(sdf.format(smdate));
		bdate = sdf.parse(sdf.format(bdate));
		Calendar cal = Calendar.getInstance();
		cal.setTime(smdate);
		long time1 = cal.getTimeInMillis();
		cal.setTime(bdate);
		long time2 = cal.getTimeInMillis();
		long between_days = time2 - time1;
		if(between_days > 0){
			return 1;
		}else if(between_days < 0){
			return -1;
		}
		return 0;
	}
	
	/**
	 * 根据指定格式将指定字符串解析成日期
	 * 
	 * @param str
	 *            指定日期
	 * @param pattern
	 *            指定格式
	 * @return 返回解析后的日期
	 */
	public static Date parse(String str, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
		try {
			return sdf.parse(str);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 根据指定格式将指定字符串解析成日期
	 *
	 * @param str
	 *            指定日期
	 * @param pattern
	 *            指定格式
	 * @return 返回解析后的日期
	 */
	public static Date parseEn(String str, String pattern) {
		SimpleDateFormat sdf = new SimpleDateFormat(pattern,Locale.ENGLISH);
		try {
			return sdf.parse(str);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	
	/**
	 * 获取SimpleDateFormat
	 * 
	 * @param pattern
	 *            日期格式
	 * @return SimpleDateFormat对象
	 * @throws RuntimeException
	 *             异常：非法日期格式
	 */
	private static SimpleDateFormat getDateFormat(String pattern) throws RuntimeException {
		SimpleDateFormat dateFormat = threadLocal.get();
		if (dateFormat == null) {
			synchronized (object) {
				if (dateFormat == null) {
					dateFormat = new SimpleDateFormat(pattern);
					dateFormat.setLenient(false);
					threadLocal.set(dateFormat);
				}
			}
		}
		dateFormat.applyPattern(pattern);
		return dateFormat;
	}

	/**
	 * 获取日期中的某数值。如获取月份
	 * 
	 * @param date
	 *            日期
	 * @param dateType
	 *            日期格式
	 * @return 数值
	 */
	private static int getInteger(Date date, int dateType) {
		int num = 0;
		Calendar calendar = Calendar.getInstance();
		if (date != null) {
			calendar.setTime(date);
			num = calendar.get(dateType);
		}
		return num;
	}

	/**
	 * 增加日期中某类型的某数值。如增加日期
	 * 
	 * @param date
	 *            日期字符串
	 * @param dateType
	 *            类型
	 * @param amount
	 *            数值
	 * @return 计算后日期字符串
	 */
	private static String addInteger(String date, int dateType, int amount) {
		String dateString = null;
		DateStyle dateStyle = getDateStyle(date);
		if (dateStyle != null) {
			Date myDate = StringToDate(date, dateStyle);
			myDate = addInteger(myDate, dateType, amount);
			dateString = DateToString(myDate, dateStyle);
		}
		return dateString;
	}

	/**
	 * 增加日期中某类型的某数值。如增加日期
	 * 
	 * @param date
	 *            日期
	 * @param dateType
	 *            类型
	 * @param amount
	 *            数值
	 * @return 计算后日期
	 */
	private static Date addInteger(Date date, int dateType, int amount) {
		Date myDate = null;
		if (date != null) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			calendar.add(dateType, amount);
			myDate = calendar.getTime();
		}
		return myDate;
	}

	/**
	 * 获取精确的日期
	 * 
	 * @param timestamps
	 *            时间long集合
	 * @return 日期
	 */
	private static Date getAccurateDate(List<Long> timestamps) {
		Date date = null;
		long timestamp = 0;
		Map<Long, long[]> map = new HashMap<Long, long[]>();
		List<Long> absoluteValues = new ArrayList<Long>();

		if (timestamps != null && timestamps.size() > 0) {
			if (timestamps.size() > 1) {
				for (int i = 0; i < timestamps.size(); i++) {
					for (int j = i + 1; j < timestamps.size(); j++) {
						long absoluteValue = Math.abs(timestamps.get(i) - timestamps.get(j));
						absoluteValues.add(absoluteValue);
						long[] timestampTmp = { timestamps.get(i), timestamps.get(j) };
						map.put(absoluteValue, timestampTmp);
					}
				}

				// 有可能有相等的情况。如2012-11和2012-11-01。时间戳是相等的。此时minAbsoluteValue为0
				// 因此不能将minAbsoluteValue取默认值0
				long minAbsoluteValue = -1;
				if (!absoluteValues.isEmpty()) {
					minAbsoluteValue = absoluteValues.get(0);
					for (int i = 1; i < absoluteValues.size(); i++) {
						if (minAbsoluteValue > absoluteValues.get(i)) {
							minAbsoluteValue = absoluteValues.get(i);
						}
					}
				}

				if (minAbsoluteValue != -1) {
					long[] timestampsLastTmp = map.get(minAbsoluteValue);

					long dateOne = timestampsLastTmp[0];
					long dateTwo = timestampsLastTmp[1];
					if (absoluteValues.size() > 1) {
						timestamp = Math.abs(dateOne) > Math.abs(dateTwo) ? dateOne : dateTwo;
					}
				}
			} else {
				timestamp = timestamps.get(0);
			}
		}

		if (timestamp != 0) {
			date = new Date(timestamp);
		}
		return date;
	}

	/**
	 * 判断字符串是否为日期字符串
	 * 
	 * @param date
	 *            日期字符串
	 * @return true or false
	 */
	public static boolean isDate(String date) {
		boolean isDate = false;
		if (date != null) {
			if (getDateStyle(date) != null) {
				isDate = true;
			}
		}
		return isDate;
	}

	/**
	 * 获取日期字符串的日期风格。失敗返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 日期风格
	 */
	public static DateStyle getDateStyle(String date) {
		DateStyle dateStyle = null;
		Map<Long, DateStyle> map = new HashMap<Long, DateStyle>();
		List<Long> timestamps = new ArrayList<Long>();
		for (DateStyle style : DateStyle.values()) {
			if (style.isShowOnly()) {
				continue;
			}
			Date dateTmp = null;
			if (date != null) {
				try {
					ParsePosition pos = new ParsePosition(0);
					dateTmp = getDateFormat(style.getValue()).parse(date, pos);
					if (pos.getIndex() != date.length()) {
						dateTmp = null;
					}
				} catch (Exception e) {
				}
			}
			if (dateTmp != null) {
				timestamps.add(dateTmp.getTime());
				map.put(dateTmp.getTime(), style);
			}
		}
		Date accurateDate = getAccurateDate(timestamps);
		if (accurateDate != null) {
			dateStyle = map.get(accurateDate.getTime());
		}
		return dateStyle;
	}

	/**
	 * 将日期字符串转化为日期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 日期
	 */
	public static Date StringToDate(String date) {
		DateStyle dateStyle = getDateStyle(date);
		return StringToDate(date, dateStyle);
	}

	/**
	 * 将日期字符串转化为日期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param pattern
	 *            日期格式
	 * @return 日期
	 */
	public static Date StringToDate(String date, String pattern) {
		Date myDate = null;
		if (date != null) {
			try {
				myDate = getDateFormat(pattern).parse(date);
			} catch (Exception e) {
			}
		}
		return myDate;
	}

	/**
	 * 将日期字符串转化为日期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dateStyle
	 *            日期风格
	 * @return 日期
	 */
	public static Date StringToDate(String date, DateStyle dateStyle) {
		Date myDate = null;
		if (dateStyle != null) {
			myDate = StringToDate(date, dateStyle.getValue());
		}
		return myDate;
	}

	/**
	 * 将日期转化为日期字符串。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param pattern
	 *            日期格式
	 * @return 日期字符串
	 */
	public static String DateToString(Date date, String pattern) {
		String dateString = null;
		if (date != null) {
			try {
				dateString = getDateFormat(pattern).format(date);
			} catch (Exception e) {
			}
		}
		return dateString;
	}
	
	/**
	 * 将日期转化为日期字符串。失败返回null。
	 * @param date
	 *            日期
	 * @param pattern
	 *            日期格式
	 * @return 日期字符串
	 */
	public static String DateToString(Date date, SimpleDateFormat dateFormat) {
		String dateString = null;
		if (date != null) {
			try {
				dateString = dateFormat.format(date);
			} catch (Exception e) {
			}
		}
		
		return dateString;
	}

	/**
	 * 将日期转化为日期字符串。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param pattern
	 *            日期格式
	 * @return 日期字符串
	 */
	public static String dateToString(Date date) {
		String dateString = null;
		if (date != null) {
			try {
				dateString = getDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
			} catch (Exception e) {
			}
		}
		return dateString;
	}

	/**
	 * 将日期转化为日期字符串。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dateStyle
	 *            日期风格
	 * @return 日期字符串
	 */
	public static String DateToString(Date date, DateStyle dateStyle) {
		if(date == null){
			return "";
		}
		String dateString = "";
		if (dateStyle != null) {
			dateString = DateToString(date, dateStyle.getValue());
		}
		return dateString;
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * @param date
	 *            旧日期字符串
	 * @param newPattern
	 *            新日期格式
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, String newPattern) {
		DateStyle oldDateStyle = getDateStyle(date);
		return StringToString(date, oldDateStyle, newPattern);
	}
	
	/**
	 * 英文-将日期字符串转化为另一日期字符串。失败返回null。
	 */
	public static String ymdToFormatEn(String dateStr, String newPattern) {
		Date date = DateUtil.parse(dateStr);
		String returnStr = new SimpleDateFormat(newPattern,Locale.US).format(date);
		returnStr = returnStr.replaceAll("Jan", "January").replaceAll("Feb", "February").replaceAll("Mar", "March").replaceAll("Apr", "April")
				.replaceAll("may", "May").replaceAll("Jun", "June").replaceAll("Jul", "July").replaceAll("Aug", "August")
				.replaceAll("Sept", "September").replaceAll("Oct", "October").replaceAll("Nov", "November").replaceAll("Dec", "December");
		return returnStr;
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param newDateStyle
	 *            新日期风格
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, DateStyle newDateStyle) {
		DateStyle oldDateStyle = getDateStyle(date);
		return StringToString(date, oldDateStyle, newDateStyle);
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param olddPattern
	 *            旧日期格式
	 * @param newPattern
	 *            新日期格式
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, String olddPattern, String newPattern) {
		return DateToString(StringToDate(date, olddPattern), newPattern);
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param olddDteStyle
	 *            旧日期风格
	 * @param newParttern
	 *            新日期格式
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, DateStyle olddDteStyle, String newParttern) {
		String dateString = null;
		if (olddDteStyle != null) {
			dateString = StringToString(date, olddDteStyle.getValue(), newParttern);
		}
		return dateString;
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param olddPattern
	 *            旧日期格式
	 * @param newDateStyle
	 *            新日期风格
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, String olddPattern, DateStyle newDateStyle) {
		String dateString = null;
		if (newDateStyle != null) {
			dateString = StringToString(date, olddPattern, newDateStyle.getValue());
		}
		return dateString;
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param olddDteStyle
	 *            旧日期风格
	 * @param newDateStyle
	 *            新日期风格
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, DateStyle olddDteStyle, DateStyle newDateStyle) {
		String dateString = null;
		if (olddDteStyle != null && newDateStyle != null) {
			dateString = StringToString(date, olddDteStyle.getValue(), newDateStyle.getValue());
		}
		return dateString;
	}

	/**
	 * 增加日期的年份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param yearAmount
	 *            增加数量。可为负数
	 * @return 增加年份后的日期字符串
	 */
	public static String addYear(String date, int yearAmount) {
		return addInteger(date, Calendar.YEAR, yearAmount);
	}

	/**
	 * 增加日期的年份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param yearAmount
	 *            增加数量。可为负数
	 * @return 增加年份后的日期
	 */
	public static Date addYear(Date date, int yearAmount) {
		return addInteger(date, Calendar.YEAR, yearAmount);
	}

	/**
	 * 增加日期的月份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param monthAmount
	 *            增加数量。可为负数
	 * @return 增加月份后的日期字符串
	 */
	public static String addMonth(String date, int monthAmount) {
		return addInteger(date, Calendar.MONTH, monthAmount);
	}

	/**
	 * 增加日期的月份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param monthAmount
	 *            增加数量。可为负数
	 * @return 增加月份后的日期
	 */
	public static Date addMonth(Date date, int monthAmount) {
		return addInteger(date, Calendar.MONTH, monthAmount);
	}

	/**
	 * 增加日期的天数。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加天数后的日期字符串
	 */
	public static String addDay(String date, int dayAmount) {
		return addInteger(date, Calendar.DATE, dayAmount);
	}

	/**
	 * 增加日期的天数。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加天数后的日期
	 */
	public static Date addDay(Date date, int dayAmount) {
		return addInteger(date, Calendar.DATE, dayAmount);
	}

	/**
	 * 增加日期的小时。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param hourAmount
	 *            增加数量。可为负数
	 * @return 增加小时后的日期字符串
	 */
	public static String addHour(String date, int hourAmount) {
		return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
	}

	/**
	 * 增加日期的小时。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param hourAmount
	 *            增加数量。可为负数
	 * @return 增加小时后的日期
	 */
	public static Date addHour(Date date, int hourAmount) {
		return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
	}

	/**
	 * 增加日期的分钟。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param minuteAmount
	 *            增加数量。可为负数
	 * @return 增加分钟后的日期字符串
	 */
	public static String addMinute(String date, int minuteAmount) {
		return addInteger(date, Calendar.MINUTE, minuteAmount);
	}

	/**
	 * 增加日期的分钟。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加分钟后的日期
	 */
	public static Date addMinute(Date date, int minuteAmount) {
		return addInteger(date, Calendar.MINUTE, minuteAmount);
	}

	/**
	 * 增加日期的秒钟。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加秒钟后的日期字符串
	 */
	public static String addSecond(String date, int secondAmount) {
		return addInteger(date, Calendar.SECOND, secondAmount);
	}

	/**
	 * 增加日期的秒钟。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加秒钟后的日期
	 */
	public static Date addSecond(Date date, int secondAmount) {
		return addInteger(date, Calendar.SECOND, secondAmount);
	}

	/**
	 * 获取日期的年份。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 年份
	 */
	public static int getYear(String date) {
		return getYear(StringToDate(date));
	}

	/**
	 * 获取日期的年份。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 年份
	 */
	public static int getYear(Date date) {
		return getInteger(date, Calendar.YEAR);
	}

	/**
	 * 获取日期的月份。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 月份
	 */
	public static int getMonth(String date) {
		return getMonth(StringToDate(date));
	}

	/**
	 * 获取日期的月份。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 月份
	 */
	public static int getMonth(Date date) {
		return getInteger(date, Calendar.MONTH) + 1;
	}

	/**
	 * 获取日期的天数。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 天
	 */
	public static int getDay(String date) {
		return getDay(StringToDate(date));
	}

	/**
	 * 获取日期的天数。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 天
	 */
	public static int getDay(Date date) {
		return getInteger(date, Calendar.DATE);
	}

	/**
	 * 获取日期的小时。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 小时
	 */
	public static int getHour(String date) {
		return getHour(StringToDate(date));
	}

	/**
	 * 获取日期的小时。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 小时
	 */
	public static int getHour(Date date) {
		return getInteger(date, Calendar.HOUR_OF_DAY);
	}

	/**
	 * 获取日期的分钟。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 分钟
	 */
	public static int getMinute(String date) {
		return getMinute(StringToDate(date));
	}

	/**
	 * 获取日期的分钟。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 分钟
	 */
	public static int getMinute(Date date) {
		return getInteger(date, Calendar.MINUTE);
	}

	/**
	 * 获取日期的秒钟。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 秒钟
	 */
	public static int getSecond(String date) {
		return getSecond(StringToDate(date));
	}

	/**
	 * 获取日期的秒钟。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 秒钟
	 */
	public static int getSecond(Date date) {
		return getInteger(date, Calendar.SECOND);
	}

	/**
	 * 获取日期 。默认yyyy-MM-dd格式。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 日期
	 */
	public static String getDate(String date) {
		return StringToString(date, DateStyle.YYYY_MM_DD);
	}

	/**
	 * 获取日期。默认yyyy-MM-dd格式。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @return 日期
	 */
	public static String getDate(Date date) {
		return DateToString(date, DateStyle.YYYY_MM_DD);
	}

	/**
	 * 获取日期的时间。默认HH:mm:ss格式。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 时间
	 */
	public static String getTime(String date) {
		return StringToString(date, DateStyle.HH_MM_SS);
	}

	/**
	 * 获取日期的时间。默认HH:mm:ss格式。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @return 时间
	 */
	public static String getTime(Date date) {
		return DateToString(date, DateStyle.HH_MM_SS);
	}


	/**
	 * 获取两个日期相差的天数
	 * 
	 * @param date
	 *            日期字符串
	 * @param otherDate
	 *            另一个日期字符串
	 * @return 相差天数。如果失败则返回-1
	 */
	public static int getIntervalDays(String date, String otherDate) {
		return getIntervalDays(StringToDate(date), StringToDate(otherDate));
	}

	/**
	 * 获取两个日期相差的秒
	 * 
	 * @param date
	 *            日期字符串
	 * @param otherDate
	 *            另一个日期字符串
	 * @return 相差天数。如果失败则返回-1
	 */
	public static int getIntervalSeconds(String date, String otherDate) {
		int num = -1;
		Date dateTmp = DateUtil.stringToDate(date);
		Date otherDateTmp = DateUtil.stringToDate(otherDate);
		if (dateTmp != null && otherDateTmp != null) {
			long time = Math.abs(dateTmp.getTime() - otherDateTmp.getTime());
			num = (int) (time / 1000);
		}
		return num;
	}
	
	/**
	 * @param date
	 *            日期
	 * @param otherDate
	 *            另一个日期
	 * @return 相差天数。如果失败则返回-1
	 */
	public static int getIntervalDays(Date date, Date otherDate) {
		int num = -1;
		Date dateTmp = DateUtil.StringToDate(DateUtil.getDate(date), DateStyle.YYYY_MM_DD);
		Date otherDateTmp = DateUtil.StringToDate(DateUtil.getDate(otherDate), DateStyle.YYYY_MM_DD);
		if (dateTmp != null && otherDateTmp != null) {
			long time = Math.abs(dateTmp.getTime() - otherDateTmp.getTime());
			num = (int) (time / (24 * 60 * 60 * 1000));
		}
		return num;
	}

	/**
	 * 格式化时间
	 * 
	 * @param time
	 * @return
	 */
	public static int loginDateCheck(Date date) {
		if (date == null) {
			return 0;
		}

		Calendar current = Calendar.getInstance();

		Calendar today = Calendar.getInstance(); // 今天

		today.set(Calendar.YEAR, current.get(Calendar.YEAR));
		today.set(Calendar.MONTH, current.get(Calendar.MONTH));
		today.set(Calendar.DAY_OF_MONTH, current.get(Calendar.DAY_OF_MONTH));
		// Calendar.HOUR——12小时制的小时数 Calendar.HOUR_OF_DAY——24小时制的小时数
		today.set(Calendar.HOUR_OF_DAY, 0);
		today.set(Calendar.MINUTE, 0);
		today.set(Calendar.SECOND, 0);

		Calendar yesterday = Calendar.getInstance(); // 昨天

		yesterday.set(Calendar.YEAR, current.get(Calendar.YEAR));
		yesterday.set(Calendar.MONTH, current.get(Calendar.MONTH));
		yesterday.set(Calendar.DAY_OF_MONTH, current.get(Calendar.DAY_OF_MONTH) - 1);
		yesterday.set(Calendar.HOUR_OF_DAY, 0);
		yesterday.set(Calendar.MINUTE, 0);
		yesterday.set(Calendar.SECOND, 0);

		current.setTime(date);

		if (current.after(today)) {
			// 今天
			return 0;
		} else if (current.before(today) && current.after(yesterday)) {
			// 昨天
			return 1;
		} else {
			// 2天及以上
			return 2;
		}
	}

	/**
	 * 获取某年第一天日期
	 * 
	 * @param year
	 *            年份
	 * @return Date
	 */
	public static Date getYearFirst(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		Date currYearFirst = calendar.getTime();
		return currYearFirst;
	}

	/**
	 * 获取某年最后一天日期
	 * 
	 * @param year
	 *            年份
	 * @return Date
	 */
	public static Date getYearLast(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		calendar.roll(Calendar.DAY_OF_YEAR, -1);
		Date currYearLast = calendar.getTime();

		return currYearLast;
	}

	/**
	 * 获取指定年份某月第一天日期
	 * 
	 * @param year
	 * @param month
	 * @return
	 */
	public static String getFirstDayOfMonth(int year, int month) {
		Calendar cal = Calendar.getInstance();
		// 设置年份
		cal.set(Calendar.YEAR, year);
		// 设置月份
		cal.set(Calendar.MONTH, month - 1);
		// 设置日历中月份的最大天数
		cal.set(Calendar.DAY_OF_MONTH, 1);
		// 格式化日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String firstDayOfMonth = sdf.format(cal.getTime());

		return firstDayOfMonth;
	}

	/**
	 * 获取插入数据库格式的日期
	 * 
	 * @return
	 */
	public static Date getDate() {
		return Calendar.getInstance().getTime();
	}

	/**
	 * 获取插入数据库格式的时间
	 * 
	 * @return
	 */
	public static String getSQLDate() {
		String systemdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}

	public static String getNumDate() {
		String systemdate = new SimpleDateFormat("yyyyMMddHHmmss").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}

	/**
	 * 获取插入数据库格式的时间yyyy-MM-dd
	 * 
	 * @return
	 */
	public static String getSQLDateYMD() {
		String systemdate = new SimpleDateFormat("yyyy-MM-dd").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}

	/**
	 * 获取当天日期
	 * 
	 * @return
	 */
	public static String getNowDateYMD() {
		String systemdate = new SimpleDateFormat("yyyyMMdd").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}

	/***
	 * 日期减一天、加一天
	 */
	public static String dateOperation(String option, String _date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar cl = Calendar.getInstance();
		Date date = null;

		try {
			date = (Date) sdf.parse(_date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		cl.setTime(date);
		if ("-".equals(option)) {
			// 时间减一天
			cl.add(Calendar.DAY_OF_MONTH, -1);
		} else if ("+".equals(option)) {
			// 时间加一天
			cl.add(Calendar.DAY_OF_YEAR, 1);
		} else {
			// do nothing
		}
		date = cl.getTime();
		return sdf.format(date);
	}

	/**
	 * 获取当天日期
	 * 
	 * @return
	 */
	public static String getNowDate() {
		String systemdate = new SimpleDateFormat("yyyy-MM-dd").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}
	
	/**
	 * 获取当天分钟
	 * 
	 * @return
	 */
	public static String getNowDateMinute() {
		String systemdate = new SimpleDateFormat("yyyy-MM-dd HH:mm").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}
	
	/**
	 * 获取当天日期dd/MM/yyyy
	 * @return
	 */
	public static String getDMY() {
		String systemdate = new SimpleDateFormat("dd/MM/yyyy").format(Calendar.getInstance().getTime()); // 获取系统当前时间
		return systemdate;
	}

	/**
	 * 获取去年日期dd/MM/yyyy
	 * @return
	 */
	public static String getLastDMY() {
		Date time = Calendar.getInstance().getTime();
		time.setYear(time.getYear()-1);
		String systemdate = new SimpleDateFormat("dd/MM/yyyy").format(time); // 获取系统当前时间
		return systemdate;
	}
	
	/**
	 * 产生3位随机数
	 */
	public static String getThreeRandom() {
		int random1 = (int) (Math.random() * 900 + 100);
		String random = String.valueOf(random1);
		return random;
	}

	/**
	 * 产生6位随机数
	 */
	public static String getSixRandom() {
		int random1 = (int) (Math.random() * 900000 + 100000);
		String random = String.valueOf(random1);
		return random;
	}

	/**
	 * 生成唯一流水号
	 * 
	 * @return
	 */
	public static String getSerialNum() {
		return getNumDate() + getSixRandom();
	}

	/**
	 * 将长时间格式字符串转换为时间 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param strDate
	 * @return
	 */
	public static Date strToDate(String strDate, String formatStr) {
		SimpleDateFormat formatter = new SimpleDateFormat(formatStr);
		ParsePosition pos = new ParsePosition(0);
		Date strtodate = formatter.parse(strDate, pos);
		return strtodate;
	}

	/**
	 * 将投保时间与初登日期相比是否小于九个月,日期格式：yyyyMMddHH
	 * 
	 * @param biStartDate
	 * @param enrollDate
	 * @return
	 */
	public static boolean isOffNineM(String biStartDate, Date enrollDate) {
		Calendar current = Calendar.getInstance();
		Date biDate = DateUtil.StringToDate(biStartDate, "yyyyMMddHH");
		Calendar biCarlendar = Calendar.getInstance();

		biCarlendar.setTime(biDate);

		Calendar nineMonthDayBefore = Calendar.getInstance(); // 九个月前

		nineMonthDayBefore.set(Calendar.YEAR, biCarlendar.get(Calendar.YEAR));
		nineMonthDayBefore.set(Calendar.MONTH, biCarlendar.get(Calendar.MONTH) - 9);

		System.out.println(DateToString(nineMonthDayBefore.getTime(), DateStyle.YYYY_MM_DD_HH_MM_SS));
		current.setTime(enrollDate);
		System.out.println(DateToString(current.getTime(), DateStyle.YYYY_MM_DD_HH_MM_SS));
		if (current.before(nineMonthDayBefore)) {
			return false;
		} else {
			return true;
		}

	}
	
	/**
	 * 将投保时间与初登日期相比是否小于九个月,日期格式：yyyy-MM-dd
	 * @param biStartDate
	 * @param enrollDate
	 * @return
	 */
	public static boolean isOffNineMonth(String biStartDate, Date enrollDate) {
		Calendar current = Calendar.getInstance();
		Date biDate = DateUtil.StringToDate(biStartDate, "yyyy-MM-dd");
		Calendar biCarlendar = Calendar.getInstance();

		biCarlendar.setTime(biDate);

		Calendar nineMonthDayBefore = Calendar.getInstance(); // 九个月前

		nineMonthDayBefore.set(Calendar.YEAR, biCarlendar.get(Calendar.YEAR));
		nineMonthDayBefore.set(Calendar.MONTH, biCarlendar.get(Calendar.MONTH) - 9);

		System.out.println(DateToString(nineMonthDayBefore.getTime(), DateStyle.YYYY_MM_DD_HH_MM_SS));
		current.setTime(enrollDate);
		System.out.println(DateToString(current.getTime(), DateStyle.YYYY_MM_DD_HH_MM_SS));
		if (current.before(nineMonthDayBefore)) {
			return false;
		} else {
			return true;
		}

	}


	/**
	 * 将日期yyyy-MM-dd HH:mm:ss 格式化为 yyyyMMddHHmmss
	 * 
	 * @param date
	 * @return
	 */
	public static String fomatDate(String date) {
		String dateStr = null;
		if (date == null || "".equals(date)) {
			dateStr = "";
		} else {
			try {
				dateStr = date.replaceAll(":", "").replaceAll("-", "").replaceAll(" ", "");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		return dateStr;
	}

	/**
	 * 把YYMMDDHHMMSS格式转换为date格式
	 * 
	 * @param date
	 * @return
	 */
	public static String numberToDate(String number) {
		SimpleDateFormat oldFormat = new SimpleDateFormat("yyyyMMdd");
		SimpleDateFormat newFormat = new SimpleDateFormat("yyyy-MM-dd");
		Date date = new Date();
		try {
			date = oldFormat.parse(number);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return newFormat.format(date);
	}

	/**
	 * 根据日期获得星期
	 * 
	 * @param date
	 * @return
	 */
	public static String getWeekOfDate(String dataStr) {
		String[] weekDaysCode = { "0", "1", "2", "3", "4", "5", "6" };
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(strToDate(dataStr, "yyyy-MM-dd"));
		int intWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		return weekDaysCode[intWeek];
	}

	/**
	 * 根据日期获得月份所在天数
	 * 
	 * @param date
	 * @return
	 */
	public static int getMonthDayOfDate(String dataStr) {
		if (dataStr == null || "".equals(dataStr)) {
			return -1;
		}
		Calendar ca = Calendar.getInstance();
		ca.setTime(strToDate(dataStr, "yyyy-MM-dd"));
		return ca.get(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 产生4位随机数
	 */
	public static String getFourRandom() {
		int random1 = (int) (Math.random() * 9000 + 1000);
		String random = String.valueOf(random1);
		return random;
	}
	
	/**
	 * 产生4位随机数
	 */
	public static Date unixParseDate(long timeValue) {
		//时间戳转化为Sting或Date  
	    SimpleDateFormat format =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
	    Long time=new Long(timeValue);  
	    String d = format.format(time);  
	    Date date = null;
		try {
			date = format.parse(d);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
		return date;
	}

	 
	 /**
	 * 1 前者比后者大，-1前者比后者小 0相等
	 * @param DATE1
	 * @param DATE2
	 * @return
	 */
	 public static int compareTimeStr(String DATE1, String DATE2) {
		if(DATE1 == null){
			return -1;
		}
		if(DATE2 == null){
			return 1;
		}
        DateFormat df = null;
        if(DATE1.contains(" ")){
        	df = new SimpleDateFormat(PATTERN_CLASSICAL);
        }else if(DATE1.length() ==7){
        	df = new SimpleDateFormat(PATTERN_CLASSICAL_MONTH);
        }else{
        	df = new SimpleDateFormat(PATTERN_CLASSICAL_SIMPLE);
        }
       
        try {
            Date dt1 = df.parse(DATE1);
            Date dt2 = df.parse(DATE2);
            if (dt1.getTime() > dt2.getTime()) {
                return 1;
            } else if (dt1.getTime() < dt2.getTime()) {
                return -1;
            } else {
                return 0;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return 0;
	}

	/**
	 * LocalDateTime转换为Date
	 * @param localDateTime
	 */
	public static Date localDateTime2Date( LocalDateTime localDateTime){
		ZoneId zoneId = ZoneId.systemDefault();
		ZonedDateTime zdt = localDateTime.atZone(zoneId);//Combines this date-time with a time-zone to create a  ZonedDateTime.
		return Date.from(zdt.toInstant());
	}

    /**
     * 获取某一年的第一天
     * @param year
     * @return
     */
	public static Date getStartOfYear(int year){
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, year);
        Date currYearFirst = calendar.getTime();
        return currYearFirst;
    }
		 
	/**
	 * 格式类型，type
	 * @param substring
	 * @return
	 */
	public static Date formatTime(int type,String updateTime) {
		if(updateTime == null || "".equals(updateTime)){
			return null;
		}
		if(type == 1){ //2019年5月27日
			if(updateTime.contains("日")){
				return StringToDate(updateTime, "yyyy年M月d日");
			}
			return StringToDate(updateTime, "yyyy年M月");
		}else if(type ==2){  //27 May 2019
			try {
				SimpleDateFormat dateFormat = new SimpleDateFormat("dd MMM yyyy",Locale.US);
				if(updateTime.length() == 8){
					dateFormat = new SimpleDateFormat("MMM yyyy",Locale.US);
				}
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==3){ //2019年5月30日15:57
			SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年M月d日hh:mm");
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==4){ //30 May 2019 18:44
			SimpleDateFormat dateFormat = new SimpleDateFormat("dd MMM yyyy hh:mm",Locale.US);
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==5){  //Dec 31 2015
			SimpleDateFormat dateFormat = new SimpleDateFormat("MMM dd yyyy",Locale.US);
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==6){  //2017年4月
			return StringToDate(updateTime, "yyyy年M月");
		}else if(type ==7){  //July 2014
			SimpleDateFormat dateFormat = new SimpleDateFormat("MMM yyyy",Locale.US);
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==8){  //04/2007 或者02/04/2003
			if(updateTime.length() < 8){
				return StringToDate(updateTime, "M/yyyy");
			}else{
				if(updateTime.contains("-")){
					updateTime = updateTime.replace("-", "/");
				}
				String [] arr = updateTime.split("/");
				if(arr[0].length() ==2){
					return StringToDate(updateTime, "d/M/yyyy");
				}else if(arr[0].length() ==4){
					return StringToDate(updateTime, "yyyy/M/d");
				}
				return null;
			}
		}else if(type ==9){  //20Sep 2006
			SimpleDateFormat dateFormat = new SimpleDateFormat("ddMMM yyyy",Locale.US);
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==10){  //Sep2006
			SimpleDateFormat dateFormat = new SimpleDateFormat("MMMyyyy",Locale.US);
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}else if(type ==11){ //dd-MMM-yyyy(17-DEC-2020)
			SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy",Locale.US);
			try {
				return dateFormat.parse(updateTime);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	/**
	 * 去两者最大值
	 * @param beforeDay
	 * @param day
	 * @return
	 */
	public static Integer getBigValue(Integer beforeDay, int day) {
		if(beforeDay == null){
			return day;
		}
		return beforeDay.intValue() > day?beforeDay.intValue():day;
	}

	/** 
     * 将时间戳转换为时间字符串
     */
    public static String stampToDateStr(String s){
        String res;
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long lt = new Long(s);
        Date date = new Date(lt);
        res = simpleDateFormat.format(date);
        return res;
    }
	
    /** 
     * 将时间戳转换为时间
     */
    public static Date stampToDate(String s){
    	String ss = stampToDateStr(s);
        return stringToDate(ss);
    }
    
    /**
     * 获取上月
     * @return
     */
    public static String getLastMonth(String formatStr) {
    	if(formatStr == null){
    		formatStr = "yyyyMM";
    	}
    	
        SimpleDateFormat format = new SimpleDateFormat(formatStr);
        Date date = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date); // 设置为当前时间
        calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) - 1); // 设置为上一个月
        date = calendar.getTime();
        String accDate = format.format(date);
        return accDate;
    }
    
    /**
     * 获取上月最后日期
     * @return
     */
    public static String getLastMonthDay(String formatStr) {
    	if(formatStr == null){
    		formatStr = "dd/MM/yyyy";
    	}
    	SimpleDateFormat sf=new SimpleDateFormat(formatStr);
    	Calendar calendar=Calendar.getInstance();

    	int month=calendar.get(Calendar.MONTH);

    	calendar.set(Calendar.MONTH, month-1);

    	calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
      
    	return sf.format(calendar.getTime());
    }
	
    /**
     * 获取上月最后时间
     * @return
     */
    public static String getLastMonthTime() {
    	return getLastMonthDay("yyyy-MM-dd")+" 23:59:59";
    }
    
	/**
	 * 获取2个日期之间的月份
	 * @param stime
	 * @param etime
	 * @return
	 */
	public static Set<String> getMonthSet(String stime, String etime) {
		Set<String> set = new TreeSet<String>();
		
		if(stime == null || etime == null){
			return set;
		}
		
		String y1 = stime.substring(0,7);// 开始时间
        String y2 = etime.substring(0,7);// 结束时间

        try {
            Date startDate = new SimpleDateFormat("yyyy-MM").parse(y1);
            Date endDate = new SimpleDateFormat("yyyy-MM").parse(y2);

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(startDate);
            // 获取开始年份和开始月份
            int startYear = calendar.get(Calendar.YEAR);
            int startMonth = calendar.get(Calendar.MONTH);
            // 获取结束年份和结束月份
            calendar.setTime(endDate);
            int endYear = calendar.get(Calendar.YEAR);
            int endMonth = calendar.get(Calendar.MONTH);
            //
            List<String> list = new ArrayList<String>();
            for (int i = startYear; i <= endYear; i++) {
                String date = "";
                if (startYear == endYear) {
                    for (int j = startMonth; j <= endMonth; j++) {
                        if (j < 9) {
                            date = i + "-0" + (j + 1);
                        } else {
                            date = i + "-" + (j + 1);
                        }
                        list.add(date);
                    }

                } else {
                    if (i == startYear) {
                        for (int j = startMonth; j < 12; j++) {
                            if (j < 9) {
                                date = i + "-0" + (j + 1);
                            } else {
                                date = i + "-" + (j + 1);
                            }
                            list.add(date);
                        }
                    } else if (i == endYear) {
                        for (int j = 0; j <= endMonth; j++) {
                            if (j < 9) {
                                date = i + "-0" + (j + 1);
                            } else {
                                date = i + "-" + (j + 1);
                            }
                            list.add(date);
                        }
                    } else {
                        for (int j = 0; j < 12; j++) {
                            if (j < 9) {
                                date = i + "-0" + (j + 1);
                            } else {
                                date = i + "-" + (j + 1);
                            }
                            list.add(date);
                        }
                    }

                }

            }

            // 所有的月份已经准备好
            //System.out.println(list);
            for(int i = 0;i < list.size();i++){
            	set.add(list.get(i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return set;
	}
	
	public static void main(String[] args) throws Exception {
		System.out.println(DateUtil.getIntervalDays(new Date(),stringToDate("2021-05-22 18:01:11")));
	}



}
